home *** CD-ROM | disk | FTP | other *** search
/ Kit PC World De Ampliacion De Windows 95 / Kit PC World de ampliacion de Windows 95.iso / internet / sweeper / samples / olecon~1 / framewrk / ctlhelp.cpp < prev    next >
C/C++ Source or Header  |  1995-11-30  |  7KB  |  234 lines
  1. //=--------------------------------------------------------------------------=
  2. // CtlHelper.Cpp
  3. //=--------------------------------------------------------------------------=
  4. // Copyright  1995  Microsoft Corporation.  All Rights Reserved.
  5. //
  6. // THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF 
  7. // ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO 
  8. // THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A 
  9. // PARTICULAR PURPOSE.
  10. //=--------------------------------------------------------------------------=
  11. //
  12. // helper routines for our COleControl implementation
  13. //
  14. #include "IPServer.H"
  15. #include "CtrlObj.H"
  16.  
  17. #include "CtlHelp.H"
  18. #include "Util.H"
  19. #include <windowsx.h>
  20.  
  21. // for ASSERT and FAIL
  22. //
  23. SZTHISFILE
  24.  
  25. //=--------------------------------------------------------------------------=
  26. // this is used by the window reflection code.
  27. //
  28. extern BYTE g_fRegisteredReflect;
  29. extern char g_szReflectClassName [];
  30.  
  31.  
  32. // define this here, since it's the only guid we really need to define in the
  33. // framework -- the user control defines all other interesting guids.
  34. //
  35. static const GUID IID_IControlPrv =
  36. { 0xd97180, 0xfcf7, 0x11ce, { 0xa0, 0x9e, 0x0, 0xaa, 0x0, 0x62, 0xbe, 0x57 } };
  37.  
  38.  
  39. // this table is used for copying data around, and persisting properties.
  40. // basically, it contains the size of a given data type
  41. //
  42. const BYTE g_rgcbDataTypeSize[] = {
  43.     0,                      // VT_EMPTY= 0,
  44.     0,                      // VT_NULL= 1,
  45.     sizeof(short),          // VT_I2= 2,
  46.     sizeof(long),           // VT_I4 = 3,
  47.     sizeof(float),          // VT_R4  = 4,
  48.     sizeof(double),         // VT_R8= 5,
  49.     sizeof(CURRENCY),       // VT_CY= 6,
  50.     sizeof(DATE),           // VT_DATE = 7,
  51.     sizeof(BSTR),           // VT_BSTR = 8,
  52.     sizeof(IDispatch *),    // VT_DISPATCH    = 9,
  53.     sizeof(SCODE),          // VT_ERROR    = 10,
  54.     sizeof(VARIANT_BOOL),   // VT_BOOL    = 11,
  55.     sizeof(VARIANT),        // VT_VARIANT= 12,
  56.     sizeof(IUnknown *),     // VT_UNKNOWN= 13,
  57. };
  58.  
  59. const BYTE g_rgcbPromotedDataTypeSize[] = {
  60.     0,                      // VT_EMPTY= 0,
  61.     0,                      // VT_NULL= 1,
  62.     sizeof(int ),           // VT_I2= 2,
  63.     sizeof(long),           // VT_I4 = 3,
  64.     sizeof(double),         // VT_R4  = 4,
  65.     sizeof(double),         // VT_R8= 5,
  66.     sizeof(CURRENCY),       // VT_CY= 6,
  67.     sizeof(DATE),           // VT_DATE = 7,
  68.     sizeof(BSTR),           // VT_BSTR = 8,
  69.     sizeof(IDispatch *),    // VT_DISPATCH    = 9,
  70.     sizeof(SCODE),          // VT_ERROR    = 10,
  71.     sizeof(int),            // VT_BOOL    = 11,
  72.     sizeof(VARIANT),        // VT_VARIANT= 12,
  73.     sizeof(IUnknown *),     // VT_UNKNOWN= 13,
  74. };
  75.  
  76. //=--------------------------------------------------------------------------=
  77. // _SpecialKeyState
  78. //=--------------------------------------------------------------------------=
  79. // returns a short with some information on which of the SHIFT, ALT, and CTRL
  80. // keys are set.
  81. //
  82. // Output:
  83. //    short        - bit 0 is shift, bit 1 is ctrl, bit 2 is ALT.
  84. //
  85. // Notes:
  86. //
  87. short _SpecialKeyState()
  88. {
  89.     // don't appear to be able to reduce number of calls to GetKeyState
  90.     //
  91.     BOOL bShift = (GetKeyState(VK_SHIFT) < 0);
  92.     BOOL bCtrl  = (GetKeyState(VK_CONTROL) < 0);
  93.     BOOL bAlt   = (GetKeyState(VK_MENU) < 0);
  94.  
  95.     return (short)(bShift + (bCtrl << 1) + (bAlt << 2));
  96. }
  97.  
  98.  
  99. //=--------------------------------------------------------------------------=
  100. // CopyAndAddRefObject
  101. //=--------------------------------------------------------------------------=
  102. // copies an object pointer, and then addref's the object.
  103. //
  104. // Parameters:
  105. //    void *        - [in] dest.
  106. //    const void *  - [in] src
  107. //    DWORD         - [in] size, ignored, since it's always 4
  108. //
  109. // Notes:
  110. //
  111. void WINAPI CopyAndAddRefObject
  112. (
  113.     void       *pDest,
  114.     const void *pSource,
  115.     DWORD       dwSize
  116. )
  117. {
  118.     ASSERT(pDest && pSource, "Bogus Pointer(s) passed into CopyAndAddRefObject!!!!");
  119.  
  120.     *((IUnknown **)pDest) = *((IUnknown **)pSource);
  121.     ADDREF_OBJECT(*((IUnknown **)pDest));
  122.  
  123.     return;
  124. }
  125.  
  126.  
  127. //=--------------------------------------------------------------------------=
  128. // CopyOleVerb    [helper]
  129. //=--------------------------------------------------------------------------=
  130. // copies an OLEVERB structure.  used in CStandardEnum
  131. //
  132. // Parameters:
  133. //    void *        - [out] where to copy to
  134. //    const void *  - [in]  where to copy from
  135. //    DWORD         - [in]  bytes to copy
  136. //
  137. // Notes:
  138. //
  139. void WINAPI CopyOleVerb
  140. (
  141.     void       *pvDest,
  142.     const void *pvSrc,
  143.     DWORD       cbCopy
  144. )
  145. {
  146.     VERBINFO * pVerbDest = (VERBINFO *) pvDest;
  147.     const VERBINFO * pVerbSrc = (const VERBINFO *) pvSrc;
  148.  
  149.     *pVerbDest = *pVerbSrc;
  150.     ((OLEVERB *)pVerbDest)->lpszVerbName = OLESTRFROMRESID((WORD)((VERBINFO *)pvSrc)->idVerbName);
  151. }
  152.  
  153. //=--------------------------------------------------------------------------=
  154. // ControlFromUnknown    [helper, callable]
  155. //=--------------------------------------------------------------------------=
  156. // given an unknown, get the COleControl pointer for it.
  157. //
  158. // Parameters:
  159. //    IUnknown *        - [in]
  160. //
  161. // Output:
  162. //    HRESULT
  163. //
  164. // Notes:
  165. //
  166. COleControl *ControlFromUnknown
  167. (
  168.     IUnknown *pUnk
  169. )
  170. {
  171.     COleControl *pCtl = NULL;
  172.  
  173.     if (!pUnk) return NULL;
  174.     pUnk->QueryInterface(IID_IControlPrv, (void **)&pCtl);
  175.  
  176.     return pCtl;
  177. }
  178.  
  179.  
  180.  
  181.  
  182. //=--------------------------------------------------------------------------=
  183. // CreateReflectWindow    [blech]
  184. //=--------------------------------------------------------------------------=
  185. // unfortunately, in certain cases, we have to create two windows, one of
  186. // which exists strictly to reflect messages on to the control.  Majorly
  187. // lame.  Fortunately, the number of hosts which require this is quite small.
  188. //
  189. // Parameters:
  190. //    BOOL        - [in] should it be created visible?
  191. //    HWND        - [in] parent window
  192. //    int         - [in] x pos
  193. //    int         - [in] y pos
  194. //    SIZEL *     - [in] size
  195. //
  196. // Output:
  197. //    HWND        - reflecting hwnd or NULL if it failed.
  198. //
  199. // Notes:
  200. //
  201. HWND CreateReflectWindow
  202. (
  203.     BOOL   fVisible,
  204.     HWND   hwndParent,
  205.     int    x,
  206.     int    y,
  207.     SIZEL *pSize
  208. )
  209. {
  210.     WNDCLASS wndclass;
  211.  
  212.     // first thing to do is register the window class.
  213.     //
  214.     if (!g_fRegisteredReflect) {
  215.  
  216.         memset(&wndclass, 0, sizeof(wndclass));
  217.         wndclass.lpfnWndProc = COleControl::ReflectWindowProc;
  218.         wndclass.hInstance   = g_hInstance;
  219.         wndclass.lpszClassName = g_szReflectClassName;
  220.  
  221.         if (!RegisterClass(&wndclass)) {
  222.             FAIL("Couldn't Register Parking Window Class!");
  223.             return NULL;
  224.         }
  225.         g_fRegisteredReflect = TRUE;
  226.     }
  227.  
  228.     return CreateWindowEx(0, g_szReflectClassName, NULL,
  229.                           WS_CHILD | WS_CLIPSIBLINGS |((fVisible) ? WS_VISIBLE : 0),
  230.                           x, y, pSize->cx, pSize->cy,
  231.                           hwndParent,
  232.                           NULL, g_hInstance, NULL);
  233. }
  234.